home *** CD-ROM | disk | FTP | other *** search
/ Aminet 40 / Aminet 40 (2000)(Schatztruhe)[!][Dec 2000].iso / Aminet / misc / emu / ATUtilities.lha / ATUtilities / Printer.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-09-26  |  12.8 KB  |  597 lines
  1. /* ******************************************************************* */
  2. /* **                                                               ** */
  3. /* **                      ATKeyboard Version 4.0                   ** */
  4. /* **             Copright (C) 1992-1994 by Thomas Dreibholz        ** */
  5. /* **                        All rights reserved                    ** */
  6. /* **                                                               ** */
  7. /* **                          LPT1-Verwaltung                      ** */
  8. /* **                                                               ** */
  9. /* ******************************************************************* */
  10.  
  11. #include "janus.h"
  12. #include "ATKeyboard.h"
  13.  
  14. extern struct Einstellungen  Einstellungen;
  15. extern struct Window        *WindowPtr;
  16. extern struct MsgPort       *Port3,*Port5,*Message1;
  17. extern struct Menu           Menu1;
  18. extern struct MenuItem       LPT1_Item,Kontrollfenster_Item;
  19. extern struct JanusBase     *JanusBase;
  20. extern struct IOExtPar      *ParallelRequest;
  21. extern struct TextFont      *OpalFont;
  22. EXTERN BOOL                  LPT1;
  23.  
  24.  
  25. struct LPT1Data
  26. {
  27.  UBYTE           *JanusData;
  28.  UBYTE           *Buffer;
  29.  ULONG            BufferPos;
  30.  ULONG            MaxPos;
  31.  UBYTE            Control;
  32.  UBYTE            LED;
  33.  UBYTE           *PublicBuffer;
  34.  struct SetupSig  ParallelInt;
  35. };
  36.  
  37.  
  38. BOOL CheckOutput();
  39. BOOL OpenOutput();
  40. VOID CloseOutput();
  41. VOID PrinterTask();
  42.  
  43.  
  44. UBYTE *PrinterTaskName="ATKeyboard Printer Task by Thomas Dreibholz";
  45. ULONG  transfer=0L;
  46. UBYTE  Papier=1;
  47. UBYTE  Drucker=1;
  48. UBYTE  Cache=1;
  49. UBYTE  Umlenkung;
  50. UWORD  cp1=0,cp2=0;
  51. LONG   ParallelDev=-1L;
  52.  
  53. struct LPT1Data    data;
  54. struct Window     *KWindow;
  55. struct RastPort   *KRastPort;
  56. struct Task       *LPT1Task;
  57. struct SetupSig   *ParallelInt;
  58. struct FileHandle *LPTOutput;
  59.  
  60. #define xMENUENABLED (0xffff-MENUENABLED)
  61.  
  62. UBYTE *DruckerStat[]={"Offline  ",
  63.                       "Online   "};
  64. UBYTE *PapierStat[]={"Kein Papier  ",
  65.                      "Papier okay  "};
  66. UBYTE *CacheStat[]={"Datenstau!  ",
  67.                     "%ld.%02ld%% voll    "};
  68.  
  69.  
  70. /* Text an (x,y) ausgeben */
  71. VOID GfxText(rp,x,y,tex)
  72.  struct RastPort *rp;
  73.  UWORD            x,y;
  74.  UBYTE           *tex;
  75. {
  76.  Move(rp,x,y);
  77.  Text(rp,tex,strlen(tex));
  78. }
  79.  
  80.  
  81. /* Cache-Belegung in Prozent */
  82. VOID CacheCalc(size)
  83.  ULONG size;
  84. {
  85.  UBYTE          buffer[25];
  86.  REGISTER UWORD i;
  87.  
  88.  if(KRastPort!=NULL)
  89.   {
  90.    i=(UWORD)((size*10000)/(data.MaxPos-4));
  91.    cp1=(UWORD)(i / 100);
  92.    cp2=(UWORD)(i % 100);
  93.    sprintf(&buffer,CacheStat[Cache],cp1,cp2);
  94.    GfxText(KRastPort,325,10,&buffer);
  95.   }
  96. }
  97.  
  98.  
  99. /* Kontrollfenster-Ausgabe */
  100. VOID KAusgabe(num)
  101.  UBYTE num;
  102. {
  103.  UBYTE buffer[30];
  104.  
  105.  if(KRastPort!=NULL)
  106.   {
  107.    if(num & 1)
  108.     {
  109.      sprintf(&buffer,"%ld Bytes    ",transfer);
  110.      GfxText(KRastPort,95,10,&buffer);
  111.     }
  112.    if(num & 2)
  113.     {
  114.      GfxText(KRastPort,95,20,PapierStat[Papier]);
  115.      GfxText(KRastPort,325,20,DruckerStat[Drucker]);
  116.     }
  117.   }
  118. }
  119.  
  120.  
  121. /* Kontrollfenster-Verwaltung */
  122. VOID Kontrollfenster(ende)
  123.  BOOL ende;
  124. {
  125.  if(ende==FALSE)
  126.   {
  127.    if(Kontrollfenster_Item.Flags & CHECKED)
  128.     {
  129.      if(KWindow==NULL)
  130.       {
  131.        KWindow=CreateStdWindow("ATKeyboard - LPT1 Kontrollfenster",
  132.                                75,20,450,28+BorderHeight(),
  133.                                0L,WINDOWDEPTH|WINDOWDRAG|GIMMEZEROZERO);
  134.        if(KWindow!=NULL)
  135.         {
  136.          KRastPort=KWindow->RPort;
  137.          SetFont(KRastPort,OpalFont);
  138.          SetAPen(KRastPort,1);
  139.          GfxText(KRastPort,10,10,"Transfer:");
  140.          GfxText(KRastPort,250,10,"Cache:");
  141.          GfxText(KRastPort,10,20,"Papier:");
  142.          GfxText(KRastPort,250,20,"Drucker:");
  143.          KAusgabe(3);
  144.         }
  145.       }
  146.     }
  147.    else
  148.     {
  149.      if(KWindow!=NULL)
  150.       {
  151.        KRastPort=NULL;
  152.        DeleteStdWindow(KWindow);
  153.        KWindow=NULL;
  154.       }
  155.     }
  156.    ClearMenuStrip(WindowPtr);
  157.    if(KWindow==NULL) Inaktiv(&Kontrollfenster_Item); else Aktiv(&Kontrollfenster_Item);
  158.    SetMenuStrip(WindowPtr,&Menu1);
  159.   }
  160.  else
  161.   {
  162.    if(KWindow!=NULL)
  163.     {
  164.      KRastPort=NULL;
  165.      DeleteStdWindow(KWindow);
  166.      KWindow=NULL;
  167.     }
  168.   }
  169. }
  170.  
  171.  
  172. /* LPT1 starten oder beenden */
  173. VOID KontrolliereLPT1()
  174. {
  175.  REGISTER LONG i;
  176.  REGISTER BOOL bool;
  177.  
  178.  if(LPT1==TRUE)
  179.   {
  180.    if(LPT1Task==NULL)
  181.     {
  182.      i=JanusBase->JIntTable->JanusInts[JSERV_LPT1INT];
  183.      if(i<=NULL)
  184.       {
  185.        bool=OpenOutput();
  186.        if(bool==TRUE)
  187.         {
  188.          ParallelInt=&data.ParallelInt;
  189.          LPT1Task=CreateProcess(PrinterTask,2500,PrinterTaskName,0);
  190.          if(LPT1Task!=NULL)
  191.           {
  192.            data.Buffer=AllocMem(Einstellungen.Puffergroesse*2,MEMF_PUBLIC);
  193.            if(data.Buffer!=NULL)
  194.             {
  195.              data.PublicBuffer=(ULONG)data.Buffer+(ULONG)Einstellungen.Puffergroesse;
  196.              data.BufferPos=0;
  197.              data.MaxPos=Einstellungen.Puffergroesse;
  198.              data.JanusData=JanusBase->IOAccessRAM;
  199.              InstallLPT1Int(ParallelInt);
  200.              ParallelInt->ss_Interrupt.is_Data=&data;
  201.              SetJanusHandler(JSERV_LPT1INT,ParallelInt);
  202.              SetJanusEnable(5,0);
  203.              SetJanusRequest(5,1);
  204.              SetLPT1Bits();
  205.              switch(Einstellungen.Umlenkung)
  206.               {
  207.                case 0:
  208.                  Say("the l p t 1 emulation is turned on, the output will be transferred to the parallel port");
  209.                 break;
  210.                case 1:
  211.                  Say("the l p t 1 emulation is turned on, the output will be transferred to the printer driver chosen by preferences");
  212.                 break;
  213.                case 2:
  214.                  Say("the l p t 1 emulation is turned on, the output will be transferred to a file");
  215.                 break;
  216.               }
  217.             }
  218.            else
  219.             {
  220.              PutMsg(Port5,Message1);
  221.              WaitPort(Port3);
  222.              GetMsg(Port3);
  223.              AbortLPT1();
  224.              LPT1=FALSE;
  225.              LPT1Task=NULL;
  226.             }
  227.           }
  228.         }
  229.        else
  230.         {
  231.          Say("i am unable to open l p t 1 output file");
  232.          Requester("Die LPT1-Ausgabedatei konnte","nicht eröffnet werden.","Okay",NULL);
  233.         }
  234.       }
  235.      else
  236.       {
  237.        LPT1=FALSE;
  238.        Say("the l p t 1 interrupt is already used");
  239.        Requester("Der LPT1-Interrupt ist bereits","belegt.","Okay",NULL);
  240.       }
  241.     }
  242.   }
  243.  else
  244.   {
  245.    if(LPT1Task!=NULL)
  246.     {
  247.      PutMsg(Port5,Message1);
  248.      WaitPort(Port3);
  249.      GetMsg(Port3);
  250.      SetJanusHandler(JSERV_LPT1INT,NULL);
  251.      FreeMem(data.Buffer,data.MaxPos*2);
  252.      CloseOutput();
  253.      Say("the l p t 1 emulation is turned off");
  254.      LPT1Task=NULL;
  255.      LPT1=FALSE;
  256.     }
  257.   }
  258.  ClearMenuStrip(WindowPtr);
  259.  if(LPT1==FALSE)
  260.   {
  261.    Inaktiv(&LPT1_Item);
  262.   }
  263.  else
  264.   {
  265.    Aktiv(&LPT1_Item);
  266.   }
  267.  SetMenuStrip(WindowPtr,&Menu1);
  268. }
  269.  
  270.  
  271. /* LPT1-Reset */
  272. VOID Druckerreset()
  273. {
  274.  if(LPT1==TRUE)
  275.   {
  276.    Say("resetting l p t 1 emulation");
  277.    LPT1=FALSE;
  278.    KontrolliereLPT1();
  279.    Papier=Cache=Drucker=1;
  280.    transfer=0;
  281.    cp1=cp2=0;
  282.    LPT1=TRUE;
  283.    KontrolliereLPT1();
  284.   }
  285. }
  286.  
  287.  
  288. /* Druckerstatus ermitteln */
  289. #asm
  290.    public _PrinterStat
  291. _PrinterStat:
  292.    moveq.l #0,d0
  293.    move.b $bfd000,d0
  294.    ext.w d0
  295.    ext.l d0
  296.    rts
  297. #endasm
  298.  
  299.  
  300. /* Druckerstatus prüfen */
  301. BOOL CheckOutput()
  302. {
  303.  REGISTER BOOL res;
  304.  REGISTER LONG Status;
  305.  
  306.  if(Umlenkung==2)
  307.   {
  308.    Drucker=Papier=1;
  309.    res=TRUE;
  310.   }
  311.  else
  312.   {
  313.    Status=PrinterStat();
  314.    if(Status & (1<<0)) Drucker=0; else Drucker=1;
  315.    if(Status & (1<<1)) Papier=0; else Papier=1;
  316.    if(((CheckIO(ParallelRequest))!=NULL)) res=TRUE; else res=FALSE;
  317.   }
  318.  return(res);
  319. }
  320.  
  321.  
  322. /* Datenausgabe öffnen */
  323. BOOL OpenOutput()
  324. {
  325.  REGISTER BOOL res;
  326.  
  327.  res=TRUE;
  328.  if(Einstellungen.Umlenkung==2)
  329.   {
  330.    Umlenkung=2;
  331.    LPTOutput=Open(&Einstellungen.LPT1Name,MODE_NEWFILE);
  332.    if(LPTOutput==NULL) res=FALSE;
  333.   }
  334.  else
  335.   {
  336.    Umlenkung=Einstellungen.Umlenkung;
  337.    if(Umlenkung==0)
  338.     {
  339.      ParallelDev=OpenDevice("parallel.device",0,ParallelRequest,0);
  340.     }
  341.    else
  342.     {
  343.      ParallelDev=OpenDevice("printer.device",0,ParallelRequest,0);
  344.     }
  345.    if(ParallelDev!=0) res=FALSE;
  346.   }
  347.  if(Einstellungen.LED) data.LED=0x7F; else data.LED=0x00;
  348.  return(res);
  349. }
  350.  
  351.  
  352. /* Datenausgabe schließen */
  353. VOID CloseOutput()
  354. {
  355.  if(LPTOutput)
  356.   {
  357.    Close(LPTOutput);
  358.    LPTOutput=NULL;
  359.   }
  360.  else if(ParallelDev==0)
  361.   {
  362.    AbortIO(ParallelRequest);
  363.    CloseDevice(ParallelRequest);
  364.    ParallelRequest->io_Device=NULL;
  365.    ParallelRequest->io_Unit=NULL;
  366.    ParallelDev=-1L;
  367.   }
  368.  if(data.LED) OffLED();
  369. }
  370.  
  371.  
  372. /* LPT1-Manager-Task */
  373. VOID PrinterTask()
  374. {
  375.  REGISTER WORD            time;
  376.  REGISTER BOOL            writeIt,bool;
  377.  REGISTER ULONG           size;
  378.  register struct Message *msg;
  379.  
  380.  geta4();
  381.  msg=NULL;
  382.  Papier=1;
  383.  Drucker=1;
  384.  Cache=1;
  385.  transfer=0;
  386.  Kontrollfenster(FALSE);
  387.  do
  388.   {
  389.    writeIt=FALSE;
  390.    bool=CheckOutput();
  391.    if(bool==TRUE)
  392.     {
  393.      Disable();
  394.      size=data.BufferPos;
  395.      if(size>0)
  396.       {
  397.        CopyMem(data.Buffer,data.PublicBuffer,size);
  398.        data.BufferPos=0;
  399.        writeIt=TRUE;
  400.        Enable();
  401.        ReadyLPT1(&data);
  402.       } else Enable();
  403.  
  404.      if(size>=(data.MaxPos-4)) Cache=0; else Cache=1;
  405.      CacheCalc(size);
  406.  
  407.      if(writeIt)
  408.       {
  409.        transfer+=size;
  410.        if(LPTOutput)
  411.         {
  412.          Write(LPTOutput,data.PublicBuffer,size);
  413.         }
  414.        else
  415.         {
  416.          ParallelRequest->IOPar.io_Data=data.PublicBuffer;
  417.          ParallelRequest->IOPar.io_Length=size;
  418.          ParallelRequest->IOPar.io_Command=CMD_WRITE;
  419.          SendIO(ParallelRequest);
  420.         } 
  421.        KAusgabe(3);
  422.       }
  423.      else
  424.       { 
  425.        KAusgabe(2);
  426.       }
  427.     }
  428.    else
  429.     {
  430.      if(KRastPort!=NULL)
  431.       {
  432.        Disable();
  433.        size=data.BufferPos;
  434.        Enable();
  435.        if(size>=(data.MaxPos-4)) Cache=0; else Cache=1;
  436.        CacheCalc(size);
  437.        transfer+=size;
  438.        KAusgabe(3);
  439.        transfer-=size;
  440.       }
  441.     }
  442.    time=Einstellungen.Leerungszeit;
  443.    do
  444.     {
  445.      Delay(5);
  446.      time-=5;
  447.      msg=GetMsg(Port5);
  448.     } while((time>0)&&(msg==NULL));
  449.   }
  450.  while(msg==NULL);
  451.  Kontrollfenster(TRUE);
  452.  ReplyMsg(msg);
  453. }
  454.  
  455.  
  456. #asm
  457. * LPT1 aktivieren
  458.    public _JanusBase
  459.    public _SetLPT1Bits
  460. _SetLPT1Bits:
  461.    move.l a6,-(sp)
  462.    move.l _JanusBase,a6
  463.    move.l 46(a6),a6
  464.    move.b #88,447(a6)
  465.    bclr #4,8189(a6)
  466.    move.l (sp)+,a6
  467.    rts
  468.  
  469.  
  470. * LPT1 ist wieder zur Datenübertragung bereit
  471.    public _ReadyLPT1
  472. _ReadyLPT1:
  473.    movem.l a1/a6,-(sp)
  474.    move.l 12(sp),a1
  475.    jsr Disable
  476.    move.l _JanusBase,a6
  477.    move.l 46(a6),a6
  478.    tst.b 16(a1)
  479.    beq ReadyLPT1_Okay
  480.  ; -----------------------------------------------------------
  481.    tst.b 17(a1)
  482.    beq KeineWarnung
  483.    bchg #1,$bfe001
  484. KeineWarnung:
  485.    clr.b 16(a1)
  486.    move.b #88,447(a6)
  487.    bclr #4,8189(a6)
  488.    btst #4,479(a6)
  489.    beq.s ReadyLPT1_Okay
  490.    move.b #-10,8187(a6)
  491.    bra ReadyLPT1_Okay
  492.  
  493.  ; -----------------------------------------------------------
  494. ReadyLPT1_Okay:
  495.  
  496.    jsr Enable
  497.    movem.l (sp)+,a1/a6
  498.    rts
  499.  
  500.  
  501. * Drucker ist nicht bereit
  502.    public _AbortLPT1
  503. _AbortLPT1:
  504.    move.l a6,-(sp)
  505.    move.l _JanusBase,a6
  506.    move.l 46(a6),a6
  507.    bset #4,447(a6)
  508.    bset #5,447(a6)
  509.    move.l (sp)+,a6
  510.    rts
  511.  
  512.  
  513. * Installieren des is_Code-Vektors
  514.    public _InstallLPT1Int
  515. _InstallLPT1Int:
  516.    move.l a6,-(sp)
  517.    move.l 8(sp),a6
  518.    move.l #Handler,18(a6)
  519.    move.l (sp)+,a6
  520.    rts
  521.  
  522.  
  523. * LPT1-Datentransfer Interrupt-Handler
  524. Handler:
  525.    jsr Disable
  526.    movem.l d0-d2/a0-a3,-(sp)
  527.    move.l a1,a3               ; A3=HandlerIO
  528.    move.l 0(a3),a1            ; A1=IOAccessRAM
  529.    move.l 4(a3),a2            ; A2=Memory
  530.    move.l 8(a3),d1            ; D1=Position
  531.    move.l 12(a3),d2           ; D2=MaxPos
  532.  ; -----------------------------------------------------------
  533.                           
  534.    subq.l #4,d2
  535.    cmp.l d2,d1                ; Vergl. Position und MaxPos-1
  536.    blo PosOkay                ; Kleiner -> PosOkay
  537.    beq PosWarn                ; Gleich  -> PosWarn
  538.                               ; Größer  -> PosError
  539.  
  540.  ; --- Cache ist voll ----------------------------------------
  541. PosError:
  542.    bset #4,447(a1)            ; LPT1-Bit: Drucker nicht bereit
  543.    bra Weiter                 ; Ende
  544.  
  545.  ; --- Cache hat nur noch 1 freies Byte ----------------------
  546. PosWarn:
  547.    move.b 415(a1),0(a2,d1.l)  ; Byte sichern
  548.    bset #4,447(a1)            ; LPT1-Bit: Drucker nicht bereit
  549.    addq.l #1,8(a3)            ; Pos-Zähler erhöhen
  550.    move.b #$7F,16(a3)         ; Cache-Control
  551.    bra Weiter
  552.  
  553.  ; --- Cache hat genug freie Bytes ---------------------------
  554. PosOkay:
  555.    move.b 415(a1),0(a2,d1.l)  ; Byte sichern
  556.    move.b #88,447(a1)         ; LPT1-Bits: Alles okay
  557.    addq.l #1,8(a3)            ; Pos-Zähler erhöhen
  558.  
  559.  ; -----------------------------------------------------------
  560. Reply:
  561.    bclr #4,8189(a1)
  562.    btst #4,479(a1)
  563.    beq.s Weiter
  564.    move.b #-10,8187(a1)
  565.  
  566. Weiter:
  567.    movem.l (sp)+,d0-d2/a0-a3
  568.    jsr Enable
  569.    rts
  570.  
  571.  
  572. * Interrupts sperren
  573. Disable:
  574.    movem.l d0-d7/a0-a6,-(sp)
  575.    move.l $4,a6
  576.    jsr -120(a6)
  577.    movem.l (sp)+,d0-d7/a0-a6
  578.    rts
  579.  
  580.  
  581. * Interrupts erlauben
  582. Enable:
  583.    movem.l d0-d7/a0-a6,-(sp)
  584.    move.l $4,a6
  585.    jsr -126(a6)
  586.    movem.l (sp)+,d0-d7/a0-a6
  587.    rts
  588.  
  589.  
  590. * LED ausschalten
  591.    public _OffLED
  592. _OffLED:
  593.    bclr #1,$bfe001
  594.    rts
  595. #endasm
  596.  
  597.